The C Programming
Language

#include <stdio.h>   /* include the standard I/O header */

int main(void) {
    printf("Hello, World!\n");  /* \n = newline character */
    return 0;   /* return 0 to OS = success */
}

int age;                  /* declared but uninitialized — value is garbage! */
int age = 25;             /* declaration + initialization */
const double PI = 3.14159; /* const: cannot be changed */
char letter = 'A';         /* single quotes for char literals */
char name[] = "Alice";      /* char array — a C string */

/* Multiple declarations */
int x = 1, y = 2, z = 3;

/* Implicit — compiler converts automatically (may lose data) */
int    i = 3;
double d = i;     /* int → double: safe, no data loss */
int    n = 3.9;   /* double → int: truncates to 3, no warning! */

/* Explicit cast */
int a = 7, b = 2;
double result = (double)a / b;  /* 3.5 — without cast: 3 (integer division) */

int a = 10, b = 3;
a + b   // 13  — addition
a - b   // 7   — subtraction
a * b   // 30  — multiplication
a / b   // 3   — integer division (truncates!)
a % b   // 1   — modulo (remainder)
a++     // post-increment: returns a (10), then increments to 11
++a     // pre-increment:  increments first, then returns 11
a--     // post-decrement

a == b   // equal to        ← NOTE: = is assignment, == is comparison!
a != b   // not equal to
a <  b   // less than
a >  b   // greater than
a <= b   // less than or equal to
a >= b   // greater than or equal to

a && b   // logical AND — short-circuits (stops at first false)
a || b   // logical OR  — short-circuits (stops at first true)
!a      // logical NOT

int x = 0b1010;  /* 10 in binary (C23; or use 0x0A) */
int y = 0b1100;  /* 12 */

x &  y    // AND:        0b1000  = 8
x |  y    // OR:         0b1110  = 14
x ^  y    // XOR:        0b0110  = 6
~x        // NOT:        flips all bits
x << 2    // left-shift:  multiply by 4
x >> 1    // right-shift: divide by 2

/* Common bitwise patterns */
flags |=  FLAG;     // set a bit
flags &= ~FLAG;    // clear a bit
flags ^=  FLAG;     // toggle a bit
int on = flags & FLAG;  // test a bit

/* Compound assignment */
x += 3;    // x = x + 3
x -= 3;    // x = x - 3
x *= 2;    // x = x * 2
x /= 2;    // x = x / 2
x %= 3;    // x = x % 3
x <<= 1;  // x = x << 1

/* Ternary: condition ? value_if_true : value_if_false */
int max = (a > b) ? a : b;
const char *label = (score >= 60.0) ? "PASS" : "FAIL";

if (score >= 90) {
    printf("A\n");
} else if (score >= 80) {
    printf("B\n");
} else {
    printf("Below B\n");
}

/* Braces are optional for single statements, but ALWAYS use them */

switch (choice) {
    case 1:
        printf("One\n");
        break;    /* REQUIRED — without break, execution falls through! */
    case 2:
    case 3:           /* intentional fall-through: cases 2 and 3 share a body */
        printf("Two or three\n");
        break;
    default:          /* runs when no case matches */
        printf("Other\n");
}
/* switch works with: int, char, enum — NOT with strings or floats */

/* for (initializer; condition; update) { body } */
for (int i = 0; i < 10; i++) {
    printf("%d ", i);   /* prints: 0 1 2 3 4 5 6 7 8 9 */
}

/* Reverse iteration */
for (int i = 9; i >= 0; i--) { ... }

/* Any part can be omitted — infinite loop: */
for (;;) { ... }    /* equivalent to while(1) { ... } */

int n = 0;
while (n < 5) {
    printf("%d\n", n);
    n++;
}
/* condition is checked BEFORE each iteration; may run 0 times */

int input;
do {
    printf("Enter a positive number: ");
    scanf("%d", &input);
} while (input <= 0);
/* body runs AT LEAST ONCE, condition checked after — perfect for input loops */

for (int i = 0; i < 10; i++) {
    if (i == 3) continue;  /* skip to next iteration */
    if (i == 7) break;    /* exit loop immediately  */
    printf("%d ", i);      /* prints: 0 1 2 4 5 6   */
}

/* goto — use sparingly; mostly acceptable for error cleanup */
if (error) goto cleanup;
/* ... */
cleanup:
    free(buf);
    return -1;

/* return_type  function_name ( param_type param, ... ) { body } */

int add(int a, int b) {
    return a + b;
}

void greet(char *name) {    /* void = no return value */
    printf("Hello, %s!\n", name);
}

/* Prototypes at top of file (or in a .h header) */
int  add(int a, int b);
void greet(char *name);

/* Pass by value: caller's x is NOT modified */
void doubleIt_val(int x) { x *= 2; }

/* Pass by pointer: caller's x IS modified */
void doubleIt_ptr(int *x) { *x *= 2; }

int n = 5;
doubleIt_val(n);      /* n is still 5 */
doubleIt_ptr(&n);     /* n is now 10  — & gives the address */

/* Declare: return_type (*name)(param_types) */
int (*op)(int, int);

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

op = add;  printf("%d\n", op(3,4));  /* 7  */
op = mul;  printf("%d\n", op(3,4));  /* 12 */

/* Use typedef for cleaner syntax */
typedef int (*BinaryOp)(int, int);
BinaryOp ops[] = { add, mul };  /* array of function pointers */

#include <stdarg.h>

double average(int count, ...) {
    va_list args;
    va_start(args, count);
    double sum = 0;
    for (int i = 0; i < count; i++)
        sum += va_arg(args, double);
    va_end(args);
    return sum / count;
}
/* average(3, 1.0, 2.0, 3.0) == 2.0 */

int x = 42;
int *p = &x;   /* p holds x's address (& = address-of operator) */

printf("%d\n",  x);   /* 42    — value of x */
printf("%p\n",  p);   /* 0x7fff...  — address */
printf("%d\n", *p);   /* 42    — * dereferences: value at that address */

*p = 100;     /* write through pointer — x is now 100 */

/* Pointer arithmetic */
int arr[] = {10, 20, 30};
int *q = arr;        /* points to arr[0] */
printf("%d\n", *q);      /* 10 */
printf("%d\n", *(q+1));  /* 20 — advances by sizeof(int) bytes */
q++;                   /* q now points to arr[1] */

int x = 5;
int  *p  = &x;   /* pointer to int   */
int **pp = &p;   /* pointer to pointer to int */

printf("%d\n", **pp);  /* 5 — double dereference */

/* Used when a function needs to change what a pointer points to */
void reallocRoster(Student **roster, int newCap) {
    *roster = realloc(*roster, newCap * sizeof(Student));
}

int x = 10;
const int *p1 = &x;   /* pointer to const int: can't change *p1 */
int *const p2 = &x;   /* const pointer: can't change p2 itself */
const int *const p3 = &x; /* neither can change */

/* In function params, const signals "I won't modify your data" */
void printName(const char *name) { printf("%s\n", name); }

/* Fixed-size arrays — size must be a compile-time constant */
int scores[5];                          /* uninitialized — garbage values */
int scores[5] = {90, 85, 78, 92, 88}; /* initialized */
int scores[] =  {90, 85, 78};          /* size inferred: 3 */
int zeros[100] = {0};                  /* all 100 elements set to 0 */

/* Access: zero-indexed */
scores[0] = 100;    /* first element */
scores[4] = 75;     /* last element — index = size - 1 */

/* Size of array (only works on the array itself, not a pointer to it) */
int n = sizeof(scores) / sizeof(scores[0]);  /* = 5 */

/* 2D array */
int matrix[3][4];           /* 3 rows, 4 columns */
matrix[1][2] = 42;          /* row 1, column 2 */

char name[20] = "Alice";    /* A l i c e \0 ? ? ? ...  (20 bytes total) */
char *lit     = "Hello";    /* string literal — stored in read-only memory! */

/* Read string from user — fgets is safe, gets() is DANGEROUS (never use it) */
fgets(name, sizeof(name), stdin);        /* reads up to 19 chars + '\0' */
name[strcspn(name, "\n")] = '\0';    /* strip trailing newline from fgets */

/* Define */
typedef struct {
    char   name[50];
    int    age;
    double salary;
} Employee;

/* Create and initialize */
Employee e1 = {"Alice", 30, 75000.0};
Employee e2 = {.name = "Bob", .age = 25};  /* designated initializer (C99+) */

/* Access fields with dot operator */
printf("%s is %d years old\n", e1.name, e1.age);

/* Access through a pointer with -> */
Employee *p = &e1;
printf("%s\n", p->name);   /* same as (*p).name */
p->salary = 80000.0;      /* modify through pointer */

/* Nested structs */
typedef struct {
    double x, y;
} Point;

typedef struct {
    Point  origin;
    double radius;
} Circle;

Circle c = {{0.0, 0.0}, 5.0};
printf("r=%.1f at (%.1f, %.1f)\n", c.radius, c.origin.x, c.origin.y);

typedef enum {
    NORTH = 0,
    SOUTH,   /* 1 — auto-increments */
    EAST,    /* 2 */
    WEST     /* 3 */
} Direction;

Direction dir = NORTH;
if (dir == NORTH) printf("Going north!\n");

/* Enums in switch — compiler warns if you miss a case */
switch (dir) {
    case NORTH: ... break;
    case SOUTH: ... break;
    default:    ... break;
}

/* All members share the same memory address */
union Data {
    int   i;
    float f;
    char  bytes[4];
};
/* sizeof(union Data) == sizeof(largest member) == 4 */

union Data d;
d.i = 42;          /* write as int */
/* now d.f and d.bytes are also "valid" but their interpretation changes */
/* Only the last-written member should be read */

#include <stdlib.h>

/* Allocate an array of 10 ints */
int *arr = malloc(10 * sizeof(int));

if (arr == NULL) {                  /* ALWAYS check for NULL */
    fprintf(stderr, "Out of memory!\n");
    return 1;
}

for (int i = 0; i < 10; i++) arr[i] = i * i;

/* Grow the array — CRITICAL: use a temp pointer */
int *tmp = realloc(arr, 20 * sizeof(int));
if (tmp == NULL) {
    /* realloc failed — arr is still valid, handle error */
    free(arr);
    return 1;
}
arr = tmp;  /* safe to update now */

free(arr);    /* release when done */
arr = NULL;   /* good practice: prevent use-after-free */

#include <stdio.h>

/* ── Writing ───────────────────────────────────────────── */
FILE *fp = fopen("data.txt", "w");   /* "w" = create or overwrite */
if (fp == NULL) { perror("fopen"); return 1; }

fprintf(fp, "Value: %d\n", 42);      /* like printf, but to fp */
fputs("Hello file\n", fp);
fclose(fp);                           /* ALWAYS close the file */

/* ── Reading ───────────────────────────────────────────── */
fp = fopen("data.txt", "r");
if (fp == NULL) { perror("fopen"); return 1; }

char line[256];
while (fgets(line, sizeof(line), fp) != NULL) {
    printf("%s", line);            /* fgets keeps the newline */
}
fclose(fp);

/* ── Binary I/O ─────────────────────────────────────────── */
fp = fopen("data.bin", "wb");
int nums[] = {1, 2, 3, 4};
fwrite(nums, sizeof(int), 4, fp);   /* write 4 ints */
fclose(fp);

fp = fopen("data.bin", "rb");
int read_back[4];
fread(read_back, sizeof(int), 4, fp); /* read 4 ints */
fclose(fp);

/* ── Includes ──────────────────────────────────────────── */
#include <stdio.h>         /* system header */
#include "myheader.h"       /* local header  */

/* ── Constants ─────────────────────────────────────────── */
#define PI          3.14159265
#define MAX_BUF     1024
#define SQUARE(x)   ((x) * (x))   /* macro function — parens protect operands */

/* ── Conditional compilation ────────────────────────────── */
#ifdef DEBUG
    printf("debug: x = %d\n", x);
#endif

#if defined(_WIN32)
    /* Windows-specific code */
#elif defined(__linux__)
    /* Linux-specific code */
#endif

/* ── Include guard (every .h file should have this) ─────── */
#ifndef MYHEADER_H
#define MYHEADER_H
    /* header contents */
#endif

/* Modern alternative: */
#pragma once    /* supported by all major compilers */

printf("%10d",  42);   /* right-aligned:  '        42' */
printf("%-10d", 42);   /* left-aligned:   '42        ' */
printf("%010d", 42);   /* zero-padded:    '0000000042' */
printf("%+d",   42);   /* always show sign: '+42'      */
printf("%6.2f", 3.14); /* width 6, 2 decimal:  '  3.14' */

/*
 * CONCEPT 1 — #include & #define (Preprocessor)
 * These run BEFORE compilation. #include inserts a header file.
 * #define creates a constant via text substitution (no type checking).
 */
#include <stdio.h>    /* printf, scanf, fopen, fclose, FILE */
#include <stdlib.h>   /* malloc, realloc, free, exit        */
#include <string.h>   /* strcpy, strcmp, strlen, strcspn    */
#include <ctype.h>    /* toupper (converts char to upper)   */

#define MAX_NAME      64
#define SAVE_FILE     "students.dat"
#define PASSING_SCORE 60.0

/*
 * CONCEPT 2 — enum (Named Integer Constants)
 * Assigns readable names to integers. ADD=1, VIEW=2, etc.
 * Use enums instead of bare magic numbers.
 * typedef lets us write 'MenuChoice' instead of 'enum MenuChoice'.
 */
typedef enum {
    ADD    = 1, VIEW = 2, SEARCH = 3,
    SAVE   = 4, LOAD = 5, STATS  = 6, QUIT = 7
} MenuChoice;

/*
 * CONCEPT 3 — struct (Custom Composite Data Type)
 * Groups related fields into one named type.
 * char name[MAX_NAME] is a fixed-length string (char array).
 */
typedef struct {
    char   name[MAX_NAME];  /* fixed-size char array = C string */
    int    id;
    double score;
    char   grade;
} Student;

/*
 * CONCEPT 4 — Function Prototypes
 * In C, a function must be declared before it is used.
 * These prototypes tell the compiler the signature; the full
 * definition appears after main().
 *
 * 'const Student *s' = pointer to read-only Student (we won't modify it)
 * 'Student **roster' = pointer-to-pointer (needed when function may
 *                      change what the pointer itself points to)
 */
char calculateGrade(double score);
void printStudent(const Student *s);
void addStudent(Student **roster, int *count, int *capacity);
void viewAll(const Student *roster, int count);
void searchByName(const Student *roster, int count);
void showStats(const Student *roster, int count);
void saveToFile(const Student *roster, int count);
void loadFromFile(Student **roster, int *count, int *capacity);
void printMenu(void);
void clearInputBuffer(void);

/*
 * CONCEPT 9 — Dynamic Memory
 * malloc(n * sizeof(T)) allocates n×sizeof(T) bytes on the heap.
 * Returns void* (raw pointer) or NULL on failure.
 * We start with capacity=4 and grow with realloc() when full.
 */
int main(void) {
    int      capacity = 4;
    int      count    = 0;
    Student *roster   = malloc(capacity * sizeof(Student));

    if (roster == NULL) {   /* ALWAYS check malloc's return */
        fprintf(stderr, "Fatal: out of memory\n");
        return 1;
    }

    printf("=== C Language Tour: Grade Tracker ===\n\n");

    /*
     * CONCEPT 8 — do-while loop
     * Executes the body AT LEAST ONCE, then checks the condition.
     * Perfect for menu loops where you always show the menu first.
     */
    int running = 1;
    do {
        printMenu();

        /*
         * scanf("%d", &choice) reads one integer.
         * The & gives scanf the ADDRESS of 'choice' so it can
         * write into it. Without &, scanf would get a copy.
         * scanf returns the number of items successfully read.
         */
        int choice;
        if (scanf("%d", &choice) != 1) {
            clearInputBuffer();
            printf("  Invalid input.\n\n");
            continue;
        }
        clearInputBuffer();

        /*
         * CONCEPT 8 — switch
         * Jumps directly to the matching case.
         * 'break' is REQUIRED — without it execution falls through
         * to the next case (usually a bug!).
         */
        switch (choice) {
            case ADD:    addStudent(&roster, &count, &capacity); break;
            case VIEW:   viewAll(roster, count);                 break;
            case SEARCH: searchByName(roster, count);            break;
            case SAVE:   saveToFile(roster, count);             break;
            case LOAD:   loadFromFile(&roster, &count, &capacity); break;
            case STATS:  showStats(roster, count);              break;
            case QUIT:
                printf("  Goodbye!\n\n");
                running = 0;
                break;
            default:
                printf("  Unknown option.\n\n");
        }
    } while (running);

    free(roster);    /* every malloc needs a matching free */
    roster = NULL;   /* prevent use-after-free */
    return 0;
}

/*
 * calculateGrade — if/else chain, comparison operators
 */
char calculateGrade(double score) {
    if      (score >= 90.0) return 'A';
    else if (score >= 80.0) return 'B';
    else if (score >= 70.0) return 'C';
    else if (score >= 60.0) return 'D';
    else                    return 'F';
}

/*
 * printStudent — pointer parameter, -> operator, ternary
 *
 * 'const Student *s': we CAN'T modify *s through this pointer.
 * s->name  is shorthand for  (*s).name
 * The ternary (score >= PASSING ? "PASS" : "FAIL") picks a string.
 */
void printStudent(const Student *s) {
    printf("  %-20s  ID:%04d  Score:%6.2f  Grade:%c  [%s]\n",
           s->name, s->id, s->score, s->grade,
           s->score >= PASSING_SCORE ? "PASS" : "FAIL");
}

/*
 * addStudent — realloc, fgets, input validation with while loop
 *
 * Takes Student **roster because the function may need to change
 * what roster POINTS TO after a realloc (which can move the block).
 * A pointer-to-pointer lets us update the caller's pointer.
 */
void addStudent(Student **roster, int *count, int *capacity) {
    if (*count >= *capacity) {
        int     newCap = *capacity * 2;
        /* CRITICAL: use a temp pointer — if realloc fails,
         * the original pointer is still valid.
         * Writing  *roster = realloc(*roster, ...)  would
         * overwrite the pointer on failure → memory leak!     */
        Student *tmp = realloc(*roster, newCap * sizeof(Student));
        if (tmp == NULL) { printf("  Memory error.\n"); return; }
        *roster   = tmp;
        *capacity = newCap;
        printf("  (Array grown to capacity %d)\n", newCap);
    }

    Student *s = &(*roster)[*count];  /* pointer to next empty slot */

    printf("\n  Enter student name: ");
    /* fgets(buf, size, stdin): reads up to size-1 chars safely.
     * NEVER use gets() — no bounds checking, buffer overflow risk! */
    if (fgets(s->name, MAX_NAME, stdin) == NULL) return;
    s->name[strcspn(s->name, "\n")] = '\0';  /* strip trailing \n */

    if (strlen(s->name) == 0) { printf("  Name cannot be empty.\n\n"); return; }

    s->id = *count + 1001;   /* auto-assign ID */

    /* Input validation loop — keep asking until valid */
    while (1) {
        printf("  Enter score (0-100): ");
        if (scanf("%lf", &s->score) == 1
                && s->score >= 0.0 && s->score <= 100.0) {
            clearInputBuffer();
            break;
        }
        clearInputBuffer();
        printf("  Invalid. Enter a number 0-100.\n");
    }

    s->grade = calculateGrade(s->score);
    (*count)++;

    printf("\n  Added: ");
    printStudent(s);
    printf("\n");
}

/*
 * viewAll — for loop, array-as-pointer, guard clause
 */
void viewAll(const Student *roster, int count) {
    if (count == 0) { printf("\n  No students yet.\n\n"); return; }
    printf("\n  %-20s  %-8s  %-10s  %-7s  %s\n",
           "Name", "ID", "Score", "Grade", "Result");
    printf("  %s\n", "------------------------------------------------------");
    /* for loop: init; condition; update */
    for (int i = 0; i < count; i++) {
        printStudent(&roster[i]);   /* &roster[i] = pointer to element i */
    }
    printf("\n");
}

/*
 * searchByName — strcmp, boolean flag variable
 * NOTE: We CANNOT use == to compare C strings!
 * == compares pointer addresses, not string contents.
 * strcmp(a, b) returns 0 when strings are equal.
 */
void searchByName(const Student *roster, int count) {
    if (count == 0) { printf("\n  No students.\n\n"); return; }

    char query[MAX_NAME];
    printf("\n  Enter name to search: ");
    if (fgets(query, MAX_NAME, stdin) == NULL) return;
    query[strcspn(query, "\n")] = '\0';

    int found = 0;   /* boolean flag: 0=false, 1=true */
    for (int i = 0; i < count; i++) {
        if (strcmp(roster[i].name, query) == 0) {
            if (!found) printf("\n  Results:\n");
            printStudent(&roster[i]);
            found = 1;
        }
    }
    if (!found) printf("\n  No student named \"%s\".\n", query);
    printf("\n");
}

/*
 * showStats — accumulator pattern, min/max, cast, ternary
 *
 * (double)pass / count * 100.0
 *   The cast (double)pass converts int→double BEFORE division,
 *   preventing integer division which would give 0 for pass < count.
 */
void showStats(const Student *roster, int count) {
    if (count == 0) { printf("\n  No students.\n\n"); return; }

    double sum  = 0.0, high = roster[0].score, low = roster[0].score;
    int    pass = 0,  fail = 0;

    for (int i = 0; i < count; i++) {
        sum += roster[i].score;
        if (roster[i].score > high) high = roster[i].score;
        if (roster[i].score < low)  low  = roster[i].score;
        /* ternary increments one of two counters */
        (roster[i].score >= PASSING_SCORE) ? pass++ : fail++;
    }

    printf("\n  Students  : %d\n",  count);
    printf("  Average   : %.2f\n", sum / count);
    printf("  Highest   : %.2f\n", high);
    printf("  Lowest    : %.2f\n", low);
    printf("  Pass Rate : %.1f%%\n\n",
           count > 0 ? (double)pass / count * 100.0 : 0.0);
}

/*
 * saveToFile — FILE*, fopen("w"), fprintf, fclose
 * fopen returns FILE* or NULL. Always check.
 * fprintf works like printf but writes to fp.
 * fclose flushes the buffer and closes the file descriptor.
 */
void saveToFile(const Student *roster, int count) {
    FILE *fp = fopen(SAVE_FILE, "w");
    if (fp == NULL) { perror("fopen"); return; }

    fprintf(fp, "%d\n", count);
    for (int i = 0; i < count; i++)
        fprintf(fp, "%s\n%d\n%.2f\n%c\n",
                roster[i].name, roster[i].id,
                roster[i].score, roster[i].grade);

    fclose(fp);
    printf("\n  Saved %d student(s) to \"%s\".\n\n", count, SAVE_FILE);
}

/*
 * loadFromFile — fopen("r"), fscanf, fgets, realloc
 */
void loadFromFile(Student **roster, int *count, int *capacity) {
    FILE *fp = fopen(SAVE_FILE, "r");
    if (fp == NULL) { printf("\n  No save file found.\n\n"); return; }

    int newCount;
    if (fscanf(fp, "%d\n", &newCount) != 1) {
        printf("\n  Corrupt save file.\n\n");
        fclose(fp); return;
    }

    Student *tmp = realloc(*roster, newCount * sizeof(Student));
    if (tmp == NULL && newCount > 0) {
        printf("\n  Memory error.\n\n");
        fclose(fp); return;
    }
    *roster = tmp; *capacity = newCount;

    for (int i = 0; i < newCount; i++) {
        if (fgets((*roster)[i].name, MAX_NAME, fp) == NULL) break;
        (*roster)[i].name[strcspn((*roster)[i].name, "\n")] = '\0';
        fscanf(fp, "%d\n",   &(*roster)[i].id);
        fscanf(fp, "%lf\n", &(*roster)[i].score);
        fscanf(fp, " %c\n", &(*roster)[i].grade);  /* space skips whitespace */
    }
    fclose(fp);
    *count = newCount;
    printf("\n  Loaded %d student(s) from \"%s\".\n\n", newCount, SAVE_FILE);
}

void printMenu(void) {
    printf("--- MENU ---\n");
    printf("%d. Add  %d. View  %d. Search  %d. Save  %d. Load  %d. Stats  %d. Quit\n",
           ADD, VIEW, SEARCH, SAVE, LOAD, STATS, QUIT);
    printf("Choice: ");
}

/*
 * clearInputBuffer — consume leftover chars in stdin
 * After scanf reads a number, '\n' stays in the buffer.
 * The next fgets would read that '\n' and return immediately.
 * This loop discards everything up to and including '\n'.
 */
void clearInputBuffer(void) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF)
        ;   /* empty body — work is done in the condition */
}